home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / contrib / pgperl / pg-libpq.mus < prev    next >
Encoding:
Text File  |  1992-08-27  |  10.9 KB  |  540 lines
  1. /*
  2.  * Interface to Postgres 2.0
  3.  *
  4.  * $Header: /genome/src/postgres/src/contrib/pgperl/RCS/pg-libpq.mus,v 1.3 92/
  5. 01/30 16:50:35 hartzell Exp Locker: hartzell $
  6.  *
  7.  * Tue Aug 21 14:13:40 1990  Igor Metz <metz@iam.unibe.ch>
  8.  *
  9.  * $Id: pg-libpq.mus,v 1.3 1992/02/15 20:32:32 mer Exp $
  10.  * $Log: pg-libpq.mus,v $
  11. Revision 1.3  1992/02/15  20:32:32  mer
  12. updated by George Hartzell of the Stanford Genome project
  13.  
  14. # Revision 1.3  92/01/30  16:50:35  hartzell
  15. # added PQendcopy, PQgetline, and PQputline.  Don't trust
  16. # PQgetline, since it expects a pointer to a buffer (a char *) and
  17. # I don't really believe that perl is going to give it what it
  18. # wants.
  19. # 
  20. # Revision 1.2  92/01/30  16:18:33  hartzell
  21. # reworked to work with Postgres 3.1 and Perl 4.?.
  22. # Made sure that all PQ functions were available,
  23. # commented out all others, whether 'cuz they're out of date,
  24. # renamed, or not part of the public interface as defined
  25. # by Jeff Meredith (e.g. don't begin with PQ) varies.
  26. # 
  27. # Revision 1.1  1992/01/18  02:14:01  hartzell
  28. # Initial revision
  29. #
  30. Revision 1.2  91/03/08  13:22:32  kemnitz
  31. added RCS header.
  32.  
  33. Revision 1.1  90/10/24  20:31:11  cimarron
  34. Initial revision
  35.  
  36. Revision 1.1  90/08/23  15:18:20  metz
  37. Initial revision
  38.  
  39.  * 
  40.  */
  41.  
  42. #include "tmp/libpq.h"
  43. #include "tmp/libpq-fe.h"    /* superset of ones also in libpq-be.h */
  44.  
  45. #include "EXTERN.h"
  46. #include "perl.h"
  47.  
  48. extern char *PQhost;
  49. extern char *PQport;
  50. extern char *PQtty;
  51. extern char *PQoption;
  52. extern char *PQdatabase;
  53. extern int PQportset;
  54. extern int PQxactid;
  55. extern int PQtracep;
  56.  
  57. static enum uservars {
  58.   UV_PQhost,
  59.   UV_PQport,
  60.   UV_PQtty,
  61.   UV_PQoption,
  62.   UV_PQdatabase,
  63.   UV_PQportset,
  64.   UV_PQxactid,
  65.   UV_PQtracep
  66. };
  67.  
  68. static enum usersubs {
  69.   US_PQFlushI,
  70.   US_PQclear,
  71.   US_PQdb,
  72.   US_PQendcopy,
  73.   US_PQexec, 
  74.   US_PQfinish,
  75.   US_PQfn,
  76.   US_PQfname,
  77.   US_PQfnameGroup,
  78.   US_PQfnumber,
  79.   US_PQfnumberGroup,
  80.   US_PQftype,
  81.   US_PQgetgroup,
  82.   US_PQgetline,
  83.   US_PQgetvalue,
  84.   US_PQgroup,
  85.   US_PQnfields,
  86.   US_PQnfieldsGroup,
  87.   US_PQngroups,
  88.   US_PQninstances,
  89.   US_PQninstancesGroup,
  90.   US_PQnportals,
  91.   US_PQntuples,
  92.   US_PQntuplesGroup,
  93.   US_PQparray,
  94.   US_PQpnames,
  95.   US_PQputline,
  96.   US_PQreset,
  97.   US_PQrulep,
  98.   US_PQsametype,
  99.   US_PQsetdb,
  100.   US_PQtrace,
  101.   US_PQuntrace,
  102. };
  103.  
  104. static
  105. unsigned int
  106. dbl2uint(d)
  107.      double d;
  108. {
  109.   unsigned int i = d;
  110.   return i;
  111. }
  112.  
  113. static
  114. double
  115. uint2dbl(i)
  116.      unsigned int i;
  117. {
  118.   double d = i;
  119.   return d;
  120. }
  121.  
  122.  
  123. static int usersub();
  124. static int userset();
  125. static int userval();
  126.  
  127. extern void
  128. init_postgres_stuff()
  129. {    
  130.   struct ufuncs uf;
  131.   char *filename = "libpq.c";
  132.  
  133.   uf.uf_set = userset;
  134.   uf.uf_val = userval;
  135.  
  136. #define MAGICVAR(name, ix) uf.uf_index = ix, magicname(name, &uf, sizeof uf)
  137.  
  138.   /* register PG variables */
  139.   MAGICVAR("PQhost",        UV_PQhost);
  140.   MAGICVAR("PQport",        UV_PQport);
  141.   MAGICVAR("PQtty",        UV_PQtty);
  142.   MAGICVAR("PQoption",        UV_PQoption);
  143.   MAGICVAR("PQdatabase",    UV_PQdatabase);
  144.   MAGICVAR("PQportset",        UV_PQportset);
  145.   MAGICVAR("PQxactid",        UV_PQxactid);
  146.   MAGICVAR("PQtracep",        UV_PQtracep);
  147.  
  148.   /* register PG functions */
  149.   make_usub("PQFlushI",        US_PQFlushI,        usersub, filena
  150. me);
  151.   make_usub("PQclear",        US_PQclear,        usersub, filename);
  152.   make_usub("PQdb",        US_PQdb,        usersub, filename);
  153.   make_usub("PQendcopy",    US_PQendcopy,        usersub, filename);
  154.   make_usub("PQexec",        US_PQexec,        usersub, filename);
  155.   make_usub("PQfinish",        US_PQfinish,        usersub, filena
  156. me);
  157.   make_usub("PQfn",        US_PQfn,        usersub, filename);
  158.   make_usub("PQfname",        US_PQfname,        usersub, filename);
  159.   make_usub("PQfnameGroup",    US_PQfnameGroup,    usersub, filename);
  160.   make_usub("PQfnumber",    US_PQfnumber,        usersub, filename);
  161.   make_usub("PQfnumberGroup",    US_PQfnumberGroup,    usersub, filename);
  162.   make_usub("PQftype",        US_PQftype,        usersub, filename);
  163.   make_usub("PQgetgroup",    US_PQgetgroup,        usersub, filename);
  164.   make_usub("PQgetline",    US_PQgetline,        usersub, filename);
  165.   make_usub("PQgetvalue",    US_PQgetvalue,        usersub, filename);
  166.   make_usub("PQgroup",        US_PQgroup,        usersub, filename);
  167.   make_usub("PQnfields",    US_PQnfields,        usersub, filename);
  168.   make_usub("PQnfieldsGroup",    US_PQnfieldsGroup,    usersub, filename);
  169.   make_usub("PQngroups",    US_PQngroups,        usersub, filename);
  170.   make_usub("PQninstances",    US_PQninstances,    usersub, filename);
  171.   make_usub("PQninstancesGroup", US_PQninstancesGroup,  usersub, filename);
  172.   make_usub("PQnportals",    US_PQnportals,        usersub, filename);
  173.   make_usub("PQntuples",    US_PQntuples,        usersub, filename);
  174.   make_usub("PQntuplesGroup",    US_PQntuplesGroup,    usersub, filename);
  175.   make_usub("PQparray",        US_PQparray,        usersub, filena
  176. me);
  177.   make_usub("PQpnames",        US_PQpnames,        usersub, filena
  178. me);
  179.   make_usub("PQputline",    US_PQputline,        usersub, filename);
  180.   make_usub("PQreset",        US_PQreset,        usersub, filename);
  181.   make_usub("PQrulep",        US_PQrulep,        usersub, filename);
  182.   make_usub("PQsametype",    US_PQsametype,        usersub, filename);
  183.   make_usub("PQsetdb",        US_PQsetdb,        usersub, filename);
  184.   make_usub("PQtrace",        US_PQtrace,        usersub, filename);
  185.   make_usub("PQuntrace",    US_PQuntrace,        usersub, filename);
  186. }
  187.  
  188. static int
  189. usersub(ix, sp, items)
  190.      int ix;
  191.      register int sp;
  192.      register int items;
  193. {
  194.   STR **st = stack->ary_array + sp;
  195.   register int i;
  196.   register char *tmps;
  197.   register STR *Str;        /* used in str_get and str_gnum macros */
  198.  
  199.   switch (ix) {
  200. /*
  201.  * Used for flushing out "poll" queries by the monitor.
  202.  */
  203. CASE int PQFlushI
  204. I int i_count
  205. END
  206.  
  207. /*
  208.  * free storage claimed by named portal.
  209.  */
  210. CASE void PQclear
  211. I char* pname
  212. END
  213.  
  214. /*
  215.  * Return the current database being accessed.
  216.  */
  217. CASE char* PQdb
  218. END
  219.  
  220. /*
  221.  * returns 1 if all's well?
  222.  */
  223. CASE int PQendcopy
  224. END
  225.  
  226. /*
  227.  * Send a query to the POSTGRES backend.
  228.  * The return value is a string.
  229.  * If there is an error: return "E error-message".
  230.  * If tuples are fetched from the backend, return "P portal-name".
  231.  * If a query is executed successfully but no tuples fetched,
  232.  * return "C query-command".
  233.  */
  234. CASE char* PQexec 
  235. I  char* query
  236. END
  237.  
  238. /*
  239.  * Close communication ports with the backend.
  240.  */
  241. CASE void PQfinish 
  242. END
  243.  
  244. /*
  245.  * Send a function call to the POSTGRES backend.
  246.  *
  247.  * fnid         : function id
  248.  * result_buf   : pointer to result buffer (&int if integer)
  249.  * result_len   : length of return value.
  250.  * result_is_int: If the result is an integer, this must be non-zero
  251.  * args         : pointer to a NULL terminated arg array.
  252.  *                      (length, if integer, and result-pointer)
  253.  * nargs        : # of arguments in args array.
  254.  */
  255. CASE char* PQfn 
  256. I int         fnid
  257. I void*       result_buf
  258. I int         result_len
  259. I int         result_is_int
  260. I PQArgBlock* args
  261. I int         nargs
  262. END
  263.  
  264. /*
  265.  * Return the name of a field.
  266.  */
  267. CASE char* PQfname
  268. I PortalBuffer* portal
  269. I int           tuple_index
  270. I int         field_number
  271. END
  272.  
  273. /* Return the field (attribute) name given the group index
  274.  * and field index.
  275.  */
  276. CASE char* PQfnameGroup
  277. I PortalBuffer* portal
  278. I int           group_index
  279. I int           field_number
  280. END
  281.  
  282. /*
  283.  * Return the field index of a given field name within a tuple.
  284.  */
  285. CASE int PQfnumber
  286. I PortalBuffer* portal
  287. I int           tuple_index
  288. I char*         field_name
  289. END
  290.  
  291. /* Return the field number (index) given the group index and
  292.  * the field name.
  293.  */
  294. CASE int PQfnumberGroup
  295. I  PortalBuffer* portal
  296. I int            group_index
  297. I char*          field_name
  298. END
  299.  
  300. /*
  301.  * Return the type of a field.
  302.  */
  303. CASE int PQftype
  304. I PortalBuffer* portal
  305. I int           tuple_index
  306. I int         field_number
  307. END
  308.  
  309. /*
  310.  * Return the index of the group that a particular tuple is in.
  311.  */
  312. CASE int PQgetgroup
  313. I PortalBuffer* portal
  314. I int           tuple_index
  315. END
  316.  
  317. /* 
  318.  * USER FUNCTION - gets a newline-terminated string from the backend.
  319.  */
  320. CASE int PQgetline
  321. IO char* s
  322. I int    maxlen
  323. END
  324.  
  325. /* 
  326.  * Return an attribute (field) value.
  327.  */
  328. CASE char* PQgetvalue
  329. I PortalBuffer* portal
  330. I int           tuple_index
  331. I int         field_number
  332. END
  333.  
  334. /*
  335.  * Return the tuple group that a particular tuple is in.
  336.  */
  337. CASE GroupBuffer* PQgroup
  338. I PortalBuffer* portal
  339. I int           tuple_index
  340. END
  341.  
  342. /*
  343.  * Return the number of fields in a tuple.
  344.  */
  345. CASE int PQnfields
  346. I PortalBuffer* portal
  347. I int           tuple_index
  348. END
  349.  
  350. /*
  351.  * Return the number of fields in a tuple group.
  352.  */
  353. CASE int PQnfieldsGroup
  354. I  PortalBuffer* portal
  355. I int            group_index
  356. END
  357.  
  358. /*
  359.  * Return the number of tuple groups in a portal buffer.
  360.  */
  361. CASE int PQngroups
  362. I  PortalBuffer* portal
  363. END
  364.  
  365. /*
  366.  *
  367.  */
  368. CASE int PQninstances
  369. I PortalBuffer* portal
  370. END
  371.  
  372. /*
  373.  *
  374.  */
  375. CASE int PQninstancesGroup
  376. I PortalBuffer* portal
  377. I int           group_index
  378. END
  379.  
  380. /* 
  381.  * Return the number of open portals. 
  382.  * If rule_p, only return asynchronized portals. 
  383.  */
  384. CASE int PQnportals
  385. I int rule_p
  386. END
  387.  
  388. /*
  389.  * Return the number of tuples in a portal buffer.
  390.  */
  391. CASE int PQntuples
  392. I  PortalBuffer* portal
  393. END
  394.  
  395. /*
  396.  * Return the number of tuples in a tuple group.
  397.  */
  398. CASE int PQntuplesGroup
  399. I  PortalBuffer* portal
  400. I int            group_index
  401. END
  402.  
  403. /*
  404.  * Return the portal buffer given a portal name.
  405.  */
  406. CASE PortalBuffer* PQparray
  407. I char* pname
  408. END
  409.  
  410. /* 
  411.  * Return all the portal names.
  412.  * If rule_p, only return asynchronized portals. 
  413.  */
  414. CASE void PQpnames
  415. I char** pnames
  416. I int    rule_p
  417. END
  418.  
  419. /*
  420.  * USER FUNCTION - sends a string to the backend.
  421.  */
  422. CASE int PQputline
  423. I char* s
  424. END
  425.  
  426. /*
  427.  * Reset the communication port with the backend.
  428.  */
  429. CASE void PQreset 
  430. END
  431.  
  432. /*
  433.  * Return 1 if an asynchronized portal.
  434.  */
  435. CASE int PQrulep
  436. I  PortalBuffer* portal
  437. END
  438.  
  439. /* Return 1 if the two tuples have the same type (in the
  440.  * same group).
  441.  */
  442. CASE int PQsametype
  443. I PortalBuffer* portal
  444. I int           tuple_index1
  445. I int           tuple_index2
  446. END
  447.  
  448. /*
  449.  * Make the specified database the current database.
  450.  */
  451. CASE void PQsetdb 
  452. I  char* dbname
  453. END
  454.  
  455. /*
  456.  * turn on pqdebug() tracing.
  457.  */
  458. CASE void PQtrace 
  459. END
  460.  
  461. /*
  462.  * turn off pqdebug() tracing.
  463.  */
  464. CASE void PQuntrace 
  465. END
  466.  
  467.   default:
  468.     fatal("Unimplemented user-defined subroutine");
  469.   }
  470.   return sp;
  471. }
  472.  
  473. static int
  474. userval(ix, str)
  475.      int ix;
  476.      STR *str;
  477. {
  478.   switch (ix) {
  479.   case UV_PQhost:
  480.     str_set(str, PQhost);
  481.     break;
  482.   case UV_PQport:
  483.     str_set(str, PQport);
  484.     break;
  485.   case UV_PQtty:
  486.     str_set(str, PQtty);
  487.     break;
  488.   case UV_PQoption:
  489.     str_set(str, PQoption);
  490.     break;
  491.   case UV_PQdatabase:
  492.     str_set(str, PQdatabase);
  493.     break;
  494.   case UV_PQportset:
  495.     str_numset(str, PQportset);
  496.     break;
  497.   case UV_PQxactid:
  498.     str_numset(str, PQxactid);
  499.     break;
  500.   case UV_PQtracep:
  501.     str_numset(str, PQtracep);
  502.     break;
  503.   }
  504.   return 0;
  505. }
  506.  
  507. static int
  508. userset(ix, str)
  509.      int ix;
  510.      STR *str;
  511. {
  512.   switch (ix) {
  513.   case UV_PQhost:
  514.     strcpy(PQhost, str_get(str));        /* hope it fits */
  515.     break;
  516.   case UV_PQport:
  517.     strcpy(PQport, str_get(str));        /* hope it fits */
  518.     break;
  519.   case UV_PQtty:
  520.     strcpy(PQtty, str_get(str));        /* hope it fits */
  521.     break;
  522.   case UV_PQoption:
  523.     strcpy(PQoption, str_get(str));        /* hope it fits */
  524.     break;
  525.   case UV_PQdatabase:
  526.     strcpy(PQdatabase, str_get(str));        /* hope it fits */
  527.     break;
  528.   case UV_PQportset:
  529.     PQportset = dbl2uint(str_gnum(str));
  530.     break;
  531.   case UV_PQxactid:
  532.     PQxactid = dbl2uint(str_gnum(str));
  533.     break;
  534.   case UV_PQtracep:
  535.     PQtracep = dbl2uint(str_gnum(str));
  536.     break;
  537.   }
  538.   return 0;
  539. }
  540.